/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package itm.dao.presupuesto;

//~--- non-JDK imports --------------------------------------------------------
import itm.exception.DAOException;
import itm.vo.presupuestos.fuenteRubroVO;
import itm.vo.presupuestos.presupuestosVO;
import itm.vo.presupuestos.rubroProyectoVO;
import itm.vo.presupuestos.ComponenteVO;
import itm.vo.presupuestos.PresupuestoVO;
import itm.vo.presupuestos.periodoRubroVO;
import itm.vo.proyectosInvestigacion.ProyectoInvestigacionVO;

//~--- JDK imports ------------------------------------------------------------

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Juan Carlos Preciado
 */
public class PresupuestoDAO {

    private CallableStatement callStmt = null;
    private ResultSet res = null;
    private String sql = "";
    presupuestosVO presupuestoVO = new presupuestosVO();
    Connection dbConexion;

    public PresupuestoDAO(Connection dbConexion) {
        this.dbConexion = dbConexion;
    }

    public int crearRubro(presupuestosVO rubroVO) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_CREAR_RUBRO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, rubroVO.getNombreRubro());
            callStmt.setDate(3, rubroVO.getFechaRegistro());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public int crearComponente(presupuestosVO componenteVO) throws Exception, SQLException {
        int resultado = -1;

        try {
            sql = "{call ITM_CREAR_COMPONENTE(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, componenteVO.getNombreComponente());
            callStmt.setInt(3, componenteVO.getIdRubro());
            callStmt.setInt(4, componenteVO.getValorFuenteXRubro());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String crearRubro_Fuentes_Aprobadas(presupuestosVO rubroVO) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_INSERTAR_FUENTE_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, rubroVO.getIdFuenteF());
            callStmt.setLong(3, rubroVO.getIdProyecto());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String crearRubro_Fuentes_Est(presupuestosVO rubroVO) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_INSERTAR_FUENTE_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, rubroVO.getIdFuenteF());
            callStmt.setLong(3, rubroVO.getIdProyecto());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public int crearRubro_Proy_Real(presupuestosVO rubroVO) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_CREAR_RUBRO_PROY_REAL(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroVO.getIdProyecto());
            callStmt.setInt(3, rubroVO.getTempo());
            callStmt.setString(4, rubroVO.getPeriodos());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public int crearRubro_Proy_Aprobado(presupuestosVO rubroVO) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_CREAR_RUBRO_PROY_APROBADO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroVO.getIdProyecto());
            callStmt.setInt(3, rubroVO.getTempo());
            callStmt.setString(4, rubroVO.getPeriodos());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public int crearRubro_Proy_Est(presupuestosVO PresupuestosVO) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_CREAR_RUBRO_PROY_ESTIMADO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, PresupuestosVO.getIdProyecto());
            callStmt.setInt(3, PresupuestosVO.getTempo());
            callStmt.setString(4, PresupuestosVO.getPeriodos());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String crearRubro_X_Proy_Real(presupuestosVO rubroVO) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_CREAR_RUBRO_X_PROY_REAL(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroVO.getIdProyecto());
            callStmt.setInt(3, rubroVO.getIdRubro());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String crearRubro_X_Proy_Aprobado(presupuestosVO rubroVO) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_CREAR_RUBRO_X_PROY_APROBADO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroVO.getIdProyecto());
            callStmt.setInt(3, rubroVO.getIdRubro());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String crearRubro_X_Proy_Est(presupuestosVO rubroVO) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_CREAR_RUBRO_X_PROY_ESTIMADO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroVO.getIdProyecto());
            callStmt.setInt(3, rubroVO.getIdRubro());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    /*crearPresupuesto: Crea el presupuesto para el proyecto especificado*/
    public void crearPresupuesto(PresupuestoVO presupuesto) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_PRESUPUESTO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, presupuesto.getIdProyecto());
            callStmt.setString(2, presupuesto.getStatus());
            callStmt.setString(3, presupuesto.getUsuarioCreacion());
            callStmt.registerOutParameter(4, java.sql.Types.VARCHAR);
            callStmt.execute();
            presupuesto.setIdPresupuesto(new Long(callStmt.getString(4)));
        } catch (SQLException ce) {
            ce.printStackTrace();
            throw new DAOException("No se registro el presupuesto", ce);
        }
    }

    public String insertarRubroXP_Est(presupuestosVO rubroXFuente) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_INSERTAR_VALOR_RUBRO_X_PROY_ESTIMADO(?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroXFuente.getIdProyecto());
            callStmt.setInt(3, rubroXFuente.getIdRubro());
            callStmt.setInt(4, rubroXFuente.getIdFuenteF());
            callStmt.setInt(5, rubroXFuente.getValorFuenteXRubro());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }


    /*crearPresupFuenteEst:  Inserta o actualiza la definición de un presupuesto por fuente*/
    public String registrarPresupFuenteEst(long IdPresupuesto, fuenteRubroVO rubroXFuente) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_CREAR_PRESUP_FUENTE_EST(?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, IdPresupuesto);
            callStmt.setLong(2, rubroXFuente.getIdRubro());
            callStmt.setLong(3, rubroXFuente.getIdFuenteF());
            callStmt.setLong(4, rubroXFuente.getCodigo());
            callStmt.setDouble(5, rubroXFuente.getValorFuenteF());
            callStmt.execute();
        } catch (SQLException ce) {
            ce.printStackTrace();
            throw new DAOException("No se registro el presupuesto para la fuente");
        }

        return resultado;
    }

    public String insertarRubroXPeriodo_Est(presupuestosVO rubroXPeriodo) throws Exception, SQLException {
        String resultado = "";

        try {
            sql = "{call ITM_INSERTAR_VALOR_RUBRO_X_PERIODO_ESTIMADO(?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, rubroXPeriodo.getIdProyecto());
            callStmt.setInt(3, rubroXPeriodo.getIdRubro());
            callStmt.setInt(4, rubroXPeriodo.getTempo());
            callStmt.setInt(5, rubroXPeriodo.getValorPeriodoXRubro_EST());
            callStmt.execute();
            resultado = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public List<ProyectoInvestigacionVO> listarProyecto() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<presupuestosVO> consultarRubrosProy(long idProyecto) {
        List<presupuestosVO> listaRubroProy = new ArrayList<presupuestosVO>();
        presupuestosVO rubroProyVO;

        try {
            sql = "{call ITM_LISTAR_RUBROS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            res = callStmt.executeQuery();

            while (res.next()) {
                rubroProyVO = new presupuestosVO();
                rubroProyVO.setIdRubro(res.getInt(1));
                rubroProyVO.setNombreRubro(res.getString(2));
                listaRubroProy.add(rubroProyVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaRubroProy;
    }

    public List<presupuestosVO> consultarRubrosProy_Apro(long idProyecto) {
        List<presupuestosVO> listaRubroProy = new ArrayList<presupuestosVO>();
        presupuestosVO rubroProyVO;

        try {
            sql = "{call ITM_LISTAR_RUBROS_PROYECTO_APRO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            res = callStmt.executeQuery();

            while (res.next()) {
                rubroProyVO = new presupuestosVO();
                rubroProyVO.setIdRubro(res.getInt(1));
                rubroProyVO.setNombreRubro(res.getString(2));
                listaRubroProy.add(rubroProyVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaRubroProy;
    }

    public List<rubroProyectoVO> consultarRubrosProyecto(long idProyecto) {
        List<rubroProyectoVO> listaRubroProy = new ArrayList<rubroProyectoVO>();
        rubroProyectoVO rubroProyVO;

        try {
            sql = "{call ITM_LISTAR_RUBROS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            res = callStmt.executeQuery();

            while (res.next()) {
                rubroProyVO = new rubroProyectoVO();
                rubroProyVO.setIdRubro(res.getInt(1));
                rubroProyVO.setNombreRubro(res.getString(2));
                listaRubroProy.add(rubroProyVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaRubroProy;
    }

    public List<rubroProyectoVO> consultarRubProyPresEst(long idProyecto) throws DAOException {
        List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
        String mensaje = "";
        long idPresu = 0;
        try {
            sql = "{call ITM_LISTAR_RUBROS_PROY_PRESU_EST(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            callStmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(2);
            idPresu = Long.parseLong(callStmt.getString(3));

            System.out.println(mensaje);
            System.out.println(idPresu);
            listaRubros = this.consultarRubrosProyecto(idProyecto);
            for (int i = 0; i < listaRubros.size(); i++) {
                listaRubros.get(i).setListaRubros(this.consultarFuentesProy(idProyecto));
            }
            listaRubros = this.consultarTiempoProy(idProyecto, listaRubros);
            if (listaRubros != null) {
                if (listaRubros.size() != 0) {
                    if (mensaje.equals("E_FTE")) {
                        listaRubros = this.asignarValoresRubroFuenteEst(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("E_TIM")) {
                        listaRubros = this.asignarValoresRubroFuenteEst(idPresu, listaRubros);
                        listaRubros = this.asignarValoresRubroTiempoEst(idProyecto, idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("NUEVO")) {
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.endsWith("E_COM")) {
                        listaRubros = this.asignarValoresRubroFuenteEst(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                }
            }
        } catch (Exception ce) {
            throw new DAOException("Error al consultar en la base de datos", ce);
        }
        return listaRubros;
    }

    public List<ComponenteVO> listarPresupComEst(long idProy, long idRubro, List<ComponenteVO> listaComponentes) throws DAOException {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_COMP_EST(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaComponentes.size(); i++) {
                    if (listaComponentes.get(i).getCodigoComponente() == res.getLong(1)) {
                        for (int j = 0; j < listaComponentes.get(i).getLstFuentes().size(); j++) {
                            if (listaComponentes.get(i).getLstFuentes().get(j).getIdFuenteF() == res.getLong(2)) {
                                listaComponentes.get(i).getLstFuentes().get(j).setValorFuenteF(res.getDouble(3));
                                listaComponentes.get(i).getLstFuentes().get(j).setValorPorDistribuir(res.getDouble(4));
                            }
                        }
                    }
                }
            }
            return listaComponentes;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar los datos", ex);
        }
    }

    public List<ComponenteVO> listarPresupComApr(long idProy, long idRubro, List<ComponenteVO> listaComponentes) throws DAOException {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_COMP_APR(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaComponentes.size(); i++) {
                    if (listaComponentes.get(i).getCodigoComponente() == res.getLong(1)) {
                        for (int j = 0; j < listaComponentes.get(i).getLstFuentes().size(); j++) {
                            if (listaComponentes.get(i).getLstFuentes().get(j).getIdFuenteF() == res.getLong(2)) {
                                listaComponentes.get(i).getLstFuentes().get(j).setValorFuenteF(res.getDouble(3));
                                listaComponentes.get(i).getLstFuentes().get(j).setValorPorDistribuir(res.getDouble(4));
                            }
                        }
                    }
                }
            }
            return listaComponentes;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar los datos", ex);
        }

    }

    public List<ComponenteVO> listarPresupComReal(long idProy, long idRubro, List<ComponenteVO> listaComponentes) throws DAOException {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_COMP_REAL(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaComponentes.size(); i++) {
                    if (listaComponentes.get(i).getCodigoComponente() == res.getLong(1)) {
                        for (int j = 0; j < listaComponentes.get(i).getLstFuentes().size(); j++) {
                            if (listaComponentes.get(i).getLstFuentes().get(j).getIdFuenteF() == res.getLong(2)) {
                                listaComponentes.get(i).getLstFuentes().get(j).setValorFuenteF(res.getDouble(3));
                                listaComponentes.get(i).getLstFuentes().get(j).setValorPorDistribuir(res.getDouble(4));
                            }
                        }
                    }
                }
            }
            return listaComponentes;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar los datos", ex);
        }

    }

    public List<rubroProyectoVO> asignarValoresRubroFuenteEst(long idPresu, List<rubroProyectoVO> listaRubros) {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_FTE_EST(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPresu);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getLong(1)) {
                        for (int j = 0; j < listaRubros.get(i).getListaRubros().size(); j++) {
                            if (listaRubros.get(i).getListaRubros().get(j).getIdFuenteF() == res.getLong(2)) {
                                listaRubros.get(i).getListaRubros().get(j).setValorFuenteF(res.getDouble(3));
                            }
                        }
                    }
                }
            }
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
        }

        return listaRubros;

    }

    public List<rubroProyectoVO> asignarValoresRubroTiempoEst(long idProy, long idPresu, List<rubroProyectoVO> listaRubros) {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_TIM_EST(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPresu);
            callStmt.setLong(2, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getLong(1)) {
                        for (int k = 0; k < listaRubros.get(i).getListaRubros().size(); k++) {
                            if (listaRubros.get(i).getListaRubros().get(k).getIdFuenteF() == res.getLong(3)) {
                                listaRubros.get(i).getListaRubros().get(k).setValorFuenteF(res.getDouble(5));
                            }
                        }
                        for (int j = 0; j < listaRubros.get(i).getListaPeriodos().size(); j++) {
                            if (listaRubros.get(i).getListaPeriodos().get(j).getPeriodo() == res.getLong(2)) {
                                listaRubros.get(i).getListaPeriodos().get(j).setValorPeriodo((long) res.getDouble(4));
                            }
                        }
                    }
                }
            }
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        return listaRubros;
    }

    public List<rubroProyectoVO> consultarTiempoProy(long idProyecto, List<rubroProyectoVO> listaRubros) {

        periodoRubroVO periodoRubroVO;
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_TIM(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            res = callStmt.executeQuery();
            while (res.next()) {
                periodoRubroVO = new periodoRubroVO();
                periodoRubroVO.setPeriodo(res.getInt(2));
                periodoRubroVO.setValorPeriodo(res.getLong(3));
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getLong(1)) {
                        listaRubros.get(i).getListaPeriodos().add(periodoRubroVO);
                    }
                }

            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaRubros;

    }

    public List<fuenteRubroVO> consultarFuentesProy(long idProyecto) {
        List<fuenteRubroVO> listaFuentesProy = new ArrayList<fuenteRubroVO>();
        fuenteRubroVO fuenteProyVO;

        try {
            sql = "{call ITM_LISTAR_FUENTES_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            res = callStmt.executeQuery();

            while (res.next()) {
                fuenteProyVO = new fuenteRubroVO();
                fuenteProyVO.setIdFuenteF(res.getInt(1));
                fuenteProyVO.setNombreFuenteExterna(res.getString(2));
                listaFuentesProy.add(fuenteProyVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaFuentesProy;
    }

    public List<presupuestosVO> consultarRubros() throws SQLException {
        List<presupuestosVO> listaRubro = new ArrayList<presupuestosVO>();
        presupuestosVO RubroVO;

        try {
            sql = "{call ITM_LLENAR_LISTA_RUBRO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                RubroVO = new presupuestosVO();
                RubroVO.setIdRubro(res.getInt(1));
                RubroVO.setNombreRubro(res.getString(2));
                listaRubro.add(RubroVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaRubro;
    }

    public List<ProyectoInvestigacionVO> listarProyecto_SinRubros_Est() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS_SIN_RUBROS_EST()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<ProyectoInvestigacionVO> listarProyecto_por_Apb() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS_POR_APROBAR()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<ProyectoInvestigacionVO> listarProyecto_Aprobados() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS_APROBADOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<ProyectoInvestigacionVO> listarDefProyectoXApb() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call PRC_ITM_LISTAR_DEF_PROYECTO_APRO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<ProyectoInvestigacionVO> listarProyecto_conRubros() throws Exception {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS_CON_RUBROS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public int tempoEstProy(long idProy) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_VALOR_TEMPO_PROY_EST(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.execute();
            res = callStmt.executeQuery();

            while (res.next()) {
                resultado = res.getInt("TEMPO");
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    public String tipo_Tiempo_Est(long idProy) throws Exception, SQLException {
        String resultado = "NO";

        try {
            sql = "{call ITM_TIPO_TIEMPO_EST(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.execute();
            res = callStmt.executeQuery();

            while (res.next()) {
                resultado = res.getString(1);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }
    /*
    public int valorFuenteEst(int idProy, int idRubro, int idFuenteF) throws Exception, SQLException {
    int resultado = 0;

    try {
    sql      = "{call ITM_VALOR_FUENTE_EST(?,?,?)}";
    callStmt = dbConexion.prepareCall(sql);
    callStmt.setInt(1, idProy);
    callStmt.setInt(2, idRubro);
    callStmt.setInt(3, idFuenteF);
    callStmt.execute();
    res = callStmt.executeQuery();

    while (res.next()) {
    resultado = res.getInt("VALOR_FUENTE");
    }
    } catch (SQLException ce) {
    ce.getStackTrace();
    }

    return resultado;
    }
    
    /**
    @param   idRubro  Codigo o identificador que designa el rubro del cual se deben establecer los componentes
     * @return  Listado de componentes o conceptos correspondiente a un determinado rubro
     */

    public List<ComponenteVO> consultarComponentes(int idRubro) throws DAOException {
        List<ComponenteVO> listaComponente = new ArrayList<ComponenteVO>();
        ComponenteVO componenteVO;
        try {
            sql = "{call ITM_LISTAR_RUBROS_COMPONENTES(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, idRubro);
            res = callStmt.executeQuery();

            while (res.next()) {
                componenteVO = new ComponenteVO();
                componenteVO.setCodigoComponente(res.getLong(1));
                componenteVO.setNombreComponente(res.getString(2));
                listaComponente.add(componenteVO);
            }
            res.close();
            callStmt.close();
        } catch (Exception ce) {
            ce.printStackTrace();
            throw new DAOException("Se presentaron problemas al listar los componentes de los rubros", ce);
        }
        return listaComponente;
    }

    /**
    @param   idRubro  Codigo o identificador que designa el rubro del cual se deben establecer los componentes
     * @return  Listado de componentes o conceptos correspondiente a un determinado rubro
     */
    public List<ComponenteVO> consultarPresupPorComponenteEstimado(long idRubro) throws DAOException {
        List<ComponenteVO> listaComponente = new ArrayList<ComponenteVO>();
        ComponenteVO componenteVO;
        long lngIdComponente = 0;
        long lngTemp = 0;
        double douValor = 0;
        double douValorFte = 0;

        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_COMPONENTE(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idRubro);


            res = callStmt.executeQuery();
            /*Obtine el listado del presupuesto por fuente y componente */
            while (res.next()) {
                componenteVO = new ComponenteVO();
                componenteVO.setCodigoComponente(res.getLong(1));
                componenteVO.setNombreComponente(res.getString(2));
                listaComponente.add(componenteVO);
            }
        /*      while (res.next()) {
        //Si el componente no existe agreguelo
        lngTemp = res.getLong(1);
        if (lngIdComponente != lngTemp) {
        if (lngIdComponente != 0) {
        listaComponente.add(componenteVO);
        }
        componenteVO = new ComponenteVO();
        douValor = 0;
        lngIdComponente = lngTemp;
        componenteVO.setCodigoComponente(lngIdComponente);
        componenteVO.setNombreComponente(res.getString(2));
        douValorFte = res.getDouble(3);
        componenteVO.setValorPresupuestado(douValor);
        } else {
        douValorFte = res.getDouble(3);

        }
        douValor = douValor + douValorFte;

        fuenteRubroVO fuen = new fuenteRubroVO();
        fuen.setIdFuenteF(res.getInt(4));
        System.out.println("fuen.setIdFuenteF " + fuen.getIdFuenteF());
        fuen.setNombreFuenteExterna(res.getString(5));
        fuen.setValorFuenteF(douValorFte);
        componenteVO.getLstFuentes().add(fuen);
        componenteVO.setValorPresupuestado(douValor);
        }
        if (lngIdComponente != 0) {
        listaComponente.add(componenteVO);
        }

        res.close();
        callStmt.close();*/

        } catch (Exception ce) {
            ce.printStackTrace();
            throw new DAOException("Se presentaron problemas al listar los componentes de los rubros", ce);
        }
        return listaComponente;
    }

    /**
     * Lista fuentes por rubro
     */
    public List<fuenteRubroVO> listarComponenteFuenteEst(int idRubro, long idProyecto) throws DAOException {
        List<fuenteRubroVO> listaRubro = new ArrayList<fuenteRubroVO>();
        fuenteRubroVO fuenteRubro;
        try {
            sql = "{call PRC_ITM_LISTAR_COMP_FTE(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, idRubro);
            callStmt.setLong(2, idProyecto);
            res = callStmt.executeQuery();
            while (res.next()) {
                fuenteRubro = new fuenteRubroVO();
                fuenteRubro.setIdFuenteF(res.getInt(1));
                fuenteRubro.setNombreFuenteExterna(res.getString(2));
                fuenteRubro.setValorFuenteF(res.getLong(3));
                fuenteRubro.setValorPorDistribuir(0);
                listaRubro.add(fuenteRubro);
            }
            return listaRubro;
        } catch (Exception e) {
            throw new DAOException("Error al consultar componentes y fuentes por rubro", e);
        }
    }

    public List<fuenteRubroVO> listarComponenteFuenteApr(int idRubro, long idProyecto, long idComp) throws DAOException {
        List<fuenteRubroVO> listaRubro = new ArrayList<fuenteRubroVO>();
        fuenteRubroVO fuenteRubro;
        try {
            sql = "{call PRC_ITM_LISTAR_COMP_FTE_APR(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, idRubro);
            callStmt.setLong(2, idProyecto);
            callStmt.setLong(3, idComp);
            res = callStmt.executeQuery();
            while (res.next()) {
                fuenteRubro = new fuenteRubroVO();
                fuenteRubro.setIdFuenteF(res.getInt(1));
                fuenteRubro.setNombreFuenteExterna(res.getString(2));
                fuenteRubro.setValorFuenteF(res.getLong(3));
                fuenteRubro.setValorEST(res.getDouble(4));
                fuenteRubro.setValorPorDistribuir(0);
                listaRubro.add(fuenteRubro);
            }
            return listaRubro;
        } catch (Exception e) {
            throw new DAOException("Error al consultar componentes y fuentes por rubro", e);
        }
    }

    public List<fuenteRubroVO> listarComponenteFuenteReal(int idRubro, long idProyecto, long idComp) throws DAOException {
        List<fuenteRubroVO> listaRubro = new ArrayList<fuenteRubroVO>();
        fuenteRubroVO fuenteRubro;
        try {
            sql = "{call PRC_ITM_LISTAR_COMP_FTE_REAL(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, idRubro);
            callStmt.setLong(2, idProyecto);
            callStmt.setLong(3, idComp);
            res = callStmt.executeQuery();
            while (res.next()) {
                fuenteRubro = new fuenteRubroVO();
                fuenteRubro.setIdFuenteF(res.getInt(1));
                fuenteRubro.setNombreFuenteExterna(res.getString(2));
                fuenteRubro.setValorFuenteF(res.getLong(3));
                fuenteRubro.setValorEST(res.getDouble(4));
                fuenteRubro.setValorPorDistribuir(0);
                listaRubro.add(fuenteRubro);
            }
            return listaRubro;
        } catch (Exception e) {
            throw new DAOException("Error al consultar componentes y fuentes por rubro", e);
        }
    }

    public int valorPeriodoEst(int idProy, int idRubro, int periodoactual) throws Exception, SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_VALOR_PERIODO_EST(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, idProy);
            callStmt.setInt(2, idRubro);
            callStmt.setInt(3, periodoactual);
            callStmt.execute();
            res = callStmt.executeQuery();

            while (res.next()) {
                resultado = res.getInt("VALOR_PERIODO");
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return resultado;
    }

    /**
    @param   idProyecto  Codigo o identificador del proyecto
     * @return  Listado de componentes o conceptos correspondiente a un determinado rubro
     */
    public List<fuenteRubroVO> consultarPresupPorFuenteEstimado(long idPresupuesto, long idProyecto, long idRubro) throws DAOException {
        List<fuenteRubroVO> listaVO = new ArrayList<fuenteRubroVO>();
        fuenteRubroVO objVO;
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_FUENTE(?, ?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPresupuesto);
            callStmt.setLong(2, idProyecto);
            callStmt.setLong(3, idRubro);
            res = callStmt.executeQuery();
            while (res.next()) {
                objVO = new fuenteRubroVO();
                objVO.setIdFuenteF(res.getInt(1));
                objVO.setIdRubro(res.getLong(2));
                objVO.setNombreRubro(res.getString(3));
                objVO.setValorFuenteF(res.getDouble(4));
                objVO.setNombreFuenteExterna(res.getString(5));
                listaVO.add(objVO);
            }
            res.close();
            callStmt.close();
        } catch (Exception ce) {
            throw new DAOException("Se presentaron problemas al listar los componentes de los rubros", ce);
        }
        return listaVO;
    }

    /**
    @param   idProyecto  Codigo o identificador del proyecto
     * @return  Listado de componentes o conceptos correspondiente a un determinado rubro
     */
    public void guardarPresupComponenteEstimado(long idProyecto, long idRubro, long idComponente, long idFuente, long idTipoPres, String usuario, double valor, double valorDist) throws DAOException {
        try {
            sql = "{call PRC_ITM_REGIS_PRESUP_COMPONENTE(?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idComponente);
            callStmt.setLong(4, idFuente);
            callStmt.setLong(5, idTipoPres);
            callStmt.setString(6, usuario);
            callStmt.setDouble(7, valor);
            callStmt.setDouble(8, valorDist);
            callStmt.execute();
        } catch (Exception e) {
            throw new DAOException("Se produjeron inconvenientes al guardar el presupuesto por componente", e);
        }

    }

    public void guardarPresupPeriodoEstimado(long idPeriodo, long idRubro, long idProyecto, double valorPeriodo) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_PRESUP_PERIODO_EST(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPeriodo);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idProyecto);
            callStmt.setDouble(4, valorPeriodo);
            callStmt.execute();
        } catch (Exception e) {
            throw new DAOException("Error al registrar datos en ITM_RUBRO_X_PERIODO_EST", e);

        }
    }

    public void modificarPresupuesto(long idProyecto, String status) throws DAOException {
        try {
            sql = "{call PRC_MODIFICAR_PRESUPUESTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProyecto);
            callStmt.setString(2, status);
            callStmt.executeUpdate();
        } catch (Exception e) {
            throw new DAOException("Error al modificar datos en ITM_PRESUPUESTO", e);
        }
    }

    public List<rubroProyectoVO> listarPresupFteApr(long idProy) throws DAOException {
        List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
        rubroProyectoVO rubroProyectoVO;
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_FTE_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                rubroProyectoVO = new rubroProyectoVO();
                rubroProyectoVO.setIdRubro(res.getInt(1));
                rubroProyectoVO.setNombreRubro(res.getString(2));
                listaRubros.add(rubroProyectoVO);
            }
            listaRubros = this.listarRubroFteApr(idProy, listaRubros);

            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar rubros por poyecto aprobado", ex);
        }

    }

    public List<rubroProyectoVO> listarRubrosProyPresuApr(long idProy) throws DAOException {
        List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
        String mensaje = "";
        long idPresu = 0;
        try {

            sql = "{call ITM_LISTAR_RUBROS_PROY_PRESU_APR(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(2);
            idPresu = Long.parseLong(callStmt.getString(3));
            listaRubros = this.listarPresupFteApr(idProy);
            listaRubros = this.listarPeriodoProyApr(idProy, listaRubros);
            if (listaRubros != null) {
                if (listaRubros.size() != 0) {
                    if (mensaje.equals("A_FTE")) {
                        listaRubros = this.listarPresupFteApr(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("A_TIM")) {
                        listaRubros = this.listarPresupFteApr(idPresu, listaRubros);
                        listaRubros = this.listarPresupTimApr(idProy, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("A_COM")) {
                        listaRubros = this.listarPresupFteApr(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("NUEVO")) {
                        listaRubros.get(0).setStatus(mensaje);
                    }
                }
            }
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar rubros para presupuesto aprobado", ex);
        }
        return listaRubros;

    }

    public List<rubroProyectoVO> listarPresupFteApr(long idPresu, List<rubroProyectoVO> listaRubros) throws DAOException {

        try {
            sql = "{call PRC_ITM_PRESUP_LISTAR_FUENTE_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPresu);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        for (int j = 0; j < listaRubros.get(i).getListaRubros().size(); j++) {
                            if (listaRubros.get(i).getListaRubros().get(j).getIdFuenteF() == res.getInt(2)) {
                                listaRubros.get(i).getListaRubros().get(j).setValorFuenteF(res.getDouble(3));
                            }

                        }
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al listar las fuentes por proyecto aprobado", ex);
        }

    }

    public List<rubroProyectoVO> listarRubroFteApr(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        fuenteRubroVO fuenteRubroVO;
        try {

            sql = "{call PRC_ITM_LISTAR_PRE_RUB_FTE_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                fuenteRubroVO = new fuenteRubroVO();
                fuenteRubroVO.setIdFuenteF(res.getInt(2));
                fuenteRubroVO.setNombreFuenteExterna(res.getString(3));
                fuenteRubroVO.setValorEST(res.getDouble(4));
                fuenteRubroVO.setValorFuenteF(res.getDouble(4));
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        listaRubros.get(i).getListaRubros().add(fuenteRubroVO);
                    }
                }
            }
            listaRubros = this.listarPresupFteApr(this.obtenerIdPresupuesto(idProy), listaRubros);
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar fuentes X rubros por poyecto aprobado", ex);
        }


    }

    public void crearFuenteApr(long idProy, long idRubro, long idFuente, double valor) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_FTE_APR(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idFuente);
            callStmt.setDouble(4, valor);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al insertar los datos: ITM_PRESUP_FUENTE_APR", ex);
        }
    }

    public int duracionProyectoApr(long idProy) throws DAOException {
        int duracion = 0;
        try {
            sql = "{call PRC_ITM_PRESUP_DURA_PROYECTO_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                duracion = res.getInt(1);
            }
            return duracion;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar la duración del proyecto aprobado", ex);
        }

    }

    public String tipoPeriodoProyApr(long idProy) throws DAOException {
        String tipo = null;
        try {
            sql = "{call PRC_ITM_PRESUP_TIPOPER_PROYECTO_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                tipo = res.getString(1);
            }
            return tipo;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar el tipo de periodo del proyecto aprobado", ex);
        }
    }

    public List<rubroProyectoVO> listarPeriodoProyApr(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        periodoRubroVO periodoRubro;
        try {
            sql = "{call PRC_ITM_LISTAR_PERIODO_PROY_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                periodoRubro = new periodoRubroVO();
                periodoRubro.setPeriodo(res.getInt(2));
                periodoRubro.setValorPeriodo(res.getLong(3));
                periodoRubro.setValorPeriodoEst(res.getDouble(3));
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        listaRubros.get(i).getListaPeriodos().add(periodoRubro);
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al listar los periodos por proyecto aprobado", ex);
        }
    }

    public void crearPresupPeriodoApr(long idPeriodo, long idRubro, long idProy, double valorPeriodo) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_PRESUP_PERIODO_APR(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPeriodo);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idProy);
            callStmt.setDouble(4, valorPeriodo);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al registrar nuevos periodos por proyecto aprobado", ex);
        }

    }

    public List<rubroProyectoVO> listarPresupTimApr(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_TIM_APR(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        for (int j = 0; j < listaRubros.get(i).getListaPeriodos().size(); j++) {
                            if (listaRubros.get(i).getListaPeriodos().get(j).getPeriodo() == res.getInt(2)) {
                                listaRubros.get(i).getListaPeriodos().get(j).setValorPeriodo(res.getDouble(3));
                            }
                        }
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar periodos por proyecto aprobado", ex);
        }

    }

    public void crearPresupCompApr(long idProy, long idRubro, long idCompo, long idFuente, long idTipoPresu, String usuario, double valor, double valorDistri) throws DAOException {
        try {
            sql = "{call PRC_ITM_REGIS_PRESUP_COMP_APR(?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idCompo);
            callStmt.setLong(4, idFuente);
            callStmt.setLong(5, idTipoPresu);
            callStmt.setString(6, usuario);
            callStmt.setDouble(7, valor);
            callStmt.setDouble(8, valorDistri);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al crear rubro por componente para presupuesto aprobado", ex);
        }
    }

    public void crearPresupCompReal(long idProy, long idRubro, long idCompo, long idFuente, long idTipoPresu, String usuario, double valor, double valorDistri) throws DAOException {
        try {
            sql = "{call PRC_ITM_REGIS_PRESUP_COMP_REAL(?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idCompo);
            callStmt.setLong(4, idFuente);
            callStmt.setLong(5, idTipoPresu);
            callStmt.setString(6, usuario);
            callStmt.setDouble(7, valor);
            callStmt.setDouble(8, valorDistri);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al crear rubro por componente para presupuesto real", ex);
        }
    }

    public List<ProyectoInvestigacionVO> listarDefProyectoXReal() throws DAOException {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvestigacionVO;
        try {

            sql = "{call PRC_ITM_LISTAR_DEF_PROYECTO_REAL()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();
            while (res.next()) {
                proyectoInvestigacionVO = new ProyectoInvestigacionVO();
                proyectoInvestigacionVO.setIdProyecto(res.getLong(1));
                proyectoInvestigacionVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvestigacionVO);
            }
            return listaProyecto;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error en consultar proyectos para definir el presupuesto real", ex);
        }
    }

    public List<rubroProyectoVO> listarRubrosProyPresuReal(long idProy) throws DAOException {
        List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
        String mensaje = "";
        long idPresu = 0;
        try {

            sql = "{call ITM_LISTAR_RUBROS_PROY_PRESU_REAL(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(2);
            idPresu = Long.parseLong(callStmt.getString(3));
            listaRubros = this.listarPresupFteReal(idProy);
            listaRubros = this.listarPeriodoProyReal(idProy, listaRubros);
            if (listaRubros != null) {
                if (listaRubros.size() != 0) {
                    if (mensaje.equals("R_FTE")) {
                        listaRubros = this.listarPresupFteReal(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("R_TIM")) {
                        listaRubros = this.listarPresupFteReal(idPresu, listaRubros);
                        listaRubros = this.listarPresupTimReal(idProy, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("R_COM")) {
                        listaRubros = this.listarPresupFteReal(idPresu, listaRubros);
                        listaRubros.get(0).setStatus(mensaje);
                    }
                    if (mensaje.equals("NUEVO")) {
                        listaRubros.get(0).setStatus(mensaje);
                    }
                }
            }

        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar rubros para presupuesto real", ex);
        }
        return listaRubros;

    }

    public List<rubroProyectoVO> listarPresupFteReal(long idProy) throws DAOException {
        List<rubroProyectoVO> listaRubros = new ArrayList<rubroProyectoVO>();
        rubroProyectoVO rubroProyectoVO;
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_FTE_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                rubroProyectoVO = new rubroProyectoVO();
                rubroProyectoVO.setIdRubro(res.getInt(1));
                rubroProyectoVO.setNombreRubro(res.getString(2));
                listaRubros.add(rubroProyectoVO);
            }
            listaRubros = this.listarRubroFteReal(idProy, listaRubros);
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar rubros por proyecto para presupuesto real", ex);
        }

    }

    public List<rubroProyectoVO> listarRubroFteReal(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        fuenteRubroVO fuenteRubroVO;
        try {

            sql = "{call PRC_ITM_LISTAR_PRE_RUB_FTE_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                fuenteRubroVO = new fuenteRubroVO();
                fuenteRubroVO.setIdFuenteF(res.getInt(2));
                fuenteRubroVO.setNombreFuenteExterna(res.getString(3));
                fuenteRubroVO.setValorAPR(res.getDouble(4));
                fuenteRubroVO.setValorFuenteF(res.getDouble(4));
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        listaRubros.get(i).getListaRubros().add(fuenteRubroVO);
                    }
                }
            }
            listaRubros = this.listarPresupFteReal(this.obtenerIdPresupuesto(idProy), listaRubros);
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar fuentes X rubros por poyecto aprobado", ex);
        }
    }

    public List<rubroProyectoVO> listarPeriodoProyReal(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        periodoRubroVO periodoRubro;
        try {
            sql = "{call PRC_ITM_LISTAR_PERIODO_PROY_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                periodoRubro = new periodoRubroVO();
                periodoRubro.setPeriodo(res.getInt(2));
                periodoRubro.setValorPeriodo(res.getLong(3));
                periodoRubro.setValorPeriodoEst(res.getDouble(3));
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        listaRubros.get(i).getListaPeriodos().add(periodoRubro);
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al listar los periodos por proyecto para el presupuesto real", ex);
        }
    }

    public List<rubroProyectoVO> listarPresupFteReal(long idPresu, List<rubroProyectoVO> listaRubros) throws DAOException {

        try {
            sql = "{call PRC_ITM_PRESUP_LISTAR_FUENTE_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPresu);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        for (int j = 0; j < listaRubros.get(i).getListaRubros().size(); j++) {
                            if (listaRubros.get(i).getListaRubros().get(j).getIdFuenteF() == res.getInt(2)) {
                                listaRubros.get(i).getListaRubros().get(j).setValorFuenteF(res.getDouble(3));
                            }

                        }
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al listar las fuentes por proyecto para el presupuesto real", ex);
        }

    }

    public List<rubroProyectoVO> listarPresupTimReal(long idProy, List<rubroProyectoVO> listaRubros) throws DAOException {
        try {
            sql = "{call PRC_ITM_LISTAR_PRESUP_TIM_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                for (int i = 0; i < listaRubros.size(); i++) {
                    if (listaRubros.get(i).getIdRubro() == res.getInt(1)) {
                        for (int j = 0; j < listaRubros.get(i).getListaPeriodos().size(); j++) {
                            if (listaRubros.get(i).getListaPeriodos().get(j).getPeriodo() == res.getInt(2)) {
                                listaRubros.get(i).getListaPeriodos().get(j).setValorPeriodo(res.getDouble(3));
                            }
                        }
                    }
                }
            }
            return listaRubros;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar periodos por proyecto para el presupuesto real", ex);
        }

    }

    public void crearFuenteReal(long idProy, long idRubro, long idFuente, double valor) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_FTE_REAL(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idFuente);
            callStmt.setDouble(4, valor);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al insertar los datos: PRC_ITM_CREAR_FTE_REAL", ex);
        }
    }

    public int duracionProyectoReal(long idProy) throws DAOException {
        int duracion = 0;
        try {
            sql = "{call PRC_ITM_PRESUP_DURA_PROYECTO_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                duracion = res.getInt(1);
            }
            return duracion;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar la duración del proyecto real", ex);
        }

    }

    public String tipoPeriodoProyReal(long idProy) throws DAOException {
        String tipo = null;
        try {
            sql = "{call PRC_ITM_PRESUP_TIPOPER_PROYECTO_REAL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            res = callStmt.executeQuery();
            while (res.next()) {
                tipo = res.getString(1);
            }
            return tipo;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar el tipo de periodo del proyecto real", ex);
        }
    }

    public void crearPresupPeriodoReal(long idPeriodo, long idRubro, long idProy, double valorPeriodo) throws DAOException {
        try {
            sql = "{call PRC_ITM_CREAR_PRESUP_PERIODO_REAL(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idPeriodo);
            callStmt.setLong(2, idRubro);
            callStmt.setLong(3, idProy);
            callStmt.setDouble(4, valorPeriodo);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al registrar nuevos periodos por proyecto real", ex);
        }

    }

    public String existeCompoEst(long idProy, long idRubro) throws DAOException {
        String mensaje = "";
        try {
            sql = "{call PRC_ITM_EXISTE_COMPO_EST(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(3);
            return mensaje;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al Consultar", ex);
        }
    }

    public String existeCompoApr(long idProy, long idRubro) throws DAOException {
        String mensaje = "";
        try {
            sql = "{call PRC_ITM_EXISTE_COMPO_APR(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(3);
            return mensaje;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al Consultar", ex);
        }
    }

    public String existeCompoReal(long idProy, long idRubro) throws DAOException {
        String mensaje = "";
        try {
            sql = "{call PRC_ITM_EXISTE_COMPO_REAL(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.setLong(2, idRubro);
            callStmt.registerOutParameter(3, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(3);
            return mensaje;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al Consultar", ex);
        }
    }

    public String existePresupuestoEstimado(long idProy) throws DAOException {
        String mensaje = "";
        try {
            sql = "{call PRC_ITM_EXISTE_PRESUPUESTO_EST(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            callStmt.execute();
            mensaje = callStmt.getString(2);
            return mensaje;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al Consultar", ex);
        }
    }

    public long obtenerIdPresupuesto(long idProy) throws DAOException {
        long idPresu = 0;
        try {
            sql = "{call PRC_ITM_OBTENER_ID_PRESUPUESTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.registerOutParameter(2, java.sql.Types.BIGINT);
            callStmt.execute();
            idPresu = callStmt.getLong(2);
            return idPresu;
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al obtener id_presupuesto", ex);
        }
    }

    public void modificarStatusProyecto(long idProy) throws DAOException {
        try {
            sql = "{call PRC_MODIFICAR_STATUS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(PresupuestoDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al modificar el status del proyecto", ex);
        }

    }
}
